/**
 * @(#)KalenderZugriffMapper.java
 * 1.0, 2013-01-24
 */
package de.hdm.gruppenkalender.team04.db;

import de.hdm.gruppenkalender.team04.data.*;
import java.rmi.RemoteException;
import java.sql.*;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Mapper-Klasse, die {@link Kalender}-Zugriffsberechtigungen auf eine relationale
 * Datenbank abbildet.
 * <p>
 * Hierzu wird eine Reihe von Methoden zur Verfügung gestellt, mit deren Hilfe
 * z.B. Objekte gesucht, erzeugt, modifiziert und gelöscht werden können.
 * <p>
 * In Anlehung an:
 * de.hdm.thies.bankprojekt.db.AccountMapper
 *
 * @author Prof. Dr. Peter Thies
 *
 * @author Mathias Bendel (mb167)
 * @author Björn Fichnter (bf023)
 * @author Stefan Hettich (sh176)
 * @author René Kugel (rk044)
 * @author Mark Leonberger (ml072)
 * @author Marta Przybylski (mp070)
 *
 * @version 1.0, 2013-01-24
 *
 */
public class KalenderZugriffMapper {

    /**
     * Die Klasse KalenderZugriffMapper wird nur einmal instantiiert. Man spricht hierbei
     * von einem sogenannten <b>Singleton</b>.
     * <p>
     * Diese Variable ist durch den Bezeichner <code>static</code> nur einmal für
     * sämtliche eventuellen Instanzen dieser Klasse vorhanden. Sie speichert die
     * einzige Instanz dieser Klasse.
     *
     * @see #kalenderZugriffMapper()
     */
    private static KalenderZugriffMapper kalenderZugriffMapper;

    /**
     * Geschützter Konstruktor - verhindert die Möglichkeit, mit new neue
     * Instanzen dieser Klasse zu erzeugen.
     */
    protected KalenderZugriffMapper() {
    }

    /**
     * Diese statische Methode kann aufgrufen werden durch
     * <code>KalenderZugriffMapper.kalenderZugriffMapper()</code>. Sie stellt die
     * Singleton-Eigenschaft sicher, indem Sie dafür sorgt, daß nur eine einzige
     * Instanz von <code>KalenderZugriffMapper</code> existiert.
     *
     * @return {@link KalenderZugriffMapper}-Objekt.
     * @see #kalenderZugriffMapper 
     */
    public static KalenderZugriffMapper kalenderZugriffMapper() {
        if (kalenderZugriffMapper == null) {
            kalenderZugriffMapper = new KalenderZugriffMapper();
        }

        return kalenderZugriffMapper;
    }

    /**
     * Gibt alle Zugriffsberechtigten eines Kalenders zurück.
     *
     * @param   id
     * @return  Vector<Integer> Ein {@link Vector} mit Ids von {@link Person}en.
     */
    public Vector<Integer> findeViaKalender(int id) {
        // DB-Verbindung holen
        Connection con = DBVerbindung.connection();
        Vector<Integer> tmp = new Vector<Integer>();

        try {
            // Leeres SQL-Statement (JDBC) anlegen
            Statement stmt = con.createStatement();

            // Statement ausfüllen und als Query an die DB schicken
            ResultSet rs = stmt.executeQuery(
                    "SELECT personId FROM kalender_zugriff_person " +
                    "WHERE kalenderId =" + id + ";");

            while (rs.next()) {
                Person p = new PersonImpl();
                p.setPersonId(rs.getInt("personId"));
                tmp.add(p.getPersonId());
            }

            System.out.println(KalenderZugriffMapper.class.getName() +
                    " - findeViaKalender ausgeführt.");

            return tmp;
        } catch (RemoteException ex) {
            Logger.getLogger(KalenderZugriffMapper.class.getName()).
                    log(Level.SEVERE, null, ex);
        } catch (SQLException ex) {
            Logger.getLogger(KalenderZugriffMapper.class.getName()).
                    log(Level.SEVERE, null, ex);
        }
        return null;
    }

    /**
     * Gibt alle Kalender einer Person zurück.
     *
     * @param   id
     * @return  Vector<Integer> Ein {@link Vector} mit Ids von {@link Kalender}n.
     */
    public Vector<Integer> findeViaPerson(int id) {
        // DB-Verbindung holen
        Connection con = DBVerbindung.connection();
        Vector<Integer> tmp = new Vector<Integer>();

        try {
            // Leeres SQL-Statement (JDBC) anlegen
            Statement stmt = con.createStatement();

            // Statement ausfüllen und als Query an die DB schicken
            ResultSet rs = stmt.executeQuery(
                    "SELECT kalenderId FROM kalender_zugriff_person " +
                    "WHERE personId =" + id + ";");

            while (rs.next()) {
                Kalender k = new KalenderImpl();
                k.setKalenderId(rs.getInt("kalenderId"));
                tmp.add(k.getKalenderId());
            }

            System.out.println(KalenderZugriffMapper.class.getName() +
                    " - findeViaPerson ausgeführt.");

            return tmp;
        } catch (RemoteException ex) {
            Logger.getLogger(KalenderZugriffMapper.class.getName()).
                    log(Level.SEVERE, null, ex);
        } catch (SQLException ex) {
            Logger.getLogger(KalenderZugriffMapper.class.getName()).
                    log(Level.SEVERE, null, ex);
        }
        return null;
    }

    /**
     * Einfügen einer Zugriffsberechtigtung
     * ({@link Kalender}-Id, {@link Person}-Id)
     *
     * @param   kId
     * @param   pId
     */
    public void einfuegen(int kId, int pId) {
        // DB-Verbindung holen
        Connection con = DBVerbindung.connection();

        try {
            // Leeres SQL-Statement (JDBC) anlegen
            Statement stmt = con.createStatement();

            // Statement ausfüllen und als Query an die DB schicken
            stmt.executeUpdate(
                    "INSERT INTO kalender_zugriff_person (kalenderId, personId) " +
                    "VALUES ('" +
                    kId + "','" +
                    pId + "');");

            System.out.println(KalenderZugriffMapper.class.getName() +
                    " - einfuegen ausgeführt.");

            con.close();
        } catch (SQLException ex) {
            Logger.getLogger(KalenderZugriffMapper.class.getName()).
                    log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Einfügen einer Zugriffsberechtigtung
     * ({@link Kalender}, {@link Person})
     *
     * @param   k
     * @param   p
     */
    public void einfuegen(Kalender k, Person p) {
        try {
            this.einfuegen(k.getKalenderId(), p.getPersonId());
        } catch (RemoteException ex) {
            Logger.getLogger(KalenderZugriffMapper.class.getName()).
                    log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Löscht alle Zugriffsberechtigungen eines Kalenders.
     *
     * @param   kId
     */
    public void loeschenViaKalender(int kId) {
        // DB-Verbindung holen
        Connection con = DBVerbindung.connection();

        try {
            // Leeres SQL-Statement (JDBC) anlegen
            Statement stmt = con.createStatement();

            // Statement ausfüllen und als Query an die DB schicken
            stmt.executeUpdate("DELETE FROM kalender_zugriff_person " +
                    "WHERE kalenderId=" + kId);

            System.out.println(KalenderZugriffMapper.class.getName() +
                    " - loeschenViaKalender ausgeführt.");

        } catch (SQLException ex) {
            Logger.getLogger(KalenderZugriffMapper.class.getName()).
                    log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Löscht alle Zugriffsberechtigungen einer Person.
     *
     * @param   pId
     */
    public void loeschenViaPerson(int pId) {
        // DB-Verbindung holen
        Connection con = DBVerbindung.connection();

        try {
            // Leeres SQL-Statement (JDBC) anlegen
            Statement stmt = con.createStatement();

            // Statement ausfüllen und als Query an die DB schicken
            stmt.executeUpdate("DELETE FROM kalender_zugriff_person " +
                    "WHERE personId=" + pId);

            System.out.println(KalenderZugriffMapper.class.getName() +
                    " - loeschenViaPerson ausgeführt.");

        } catch (SQLException ex) {
            Logger.getLogger(KalenderZugriffMapper.class.getName()).
                    log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Löscht eine bestimmte Zugriffsberechtigung einer {@link Person} zu einem
     * {@link Kalender} mit Hilfe der Ids.
     *
     * @param   kId
     * @param   pId
     */
    public void loeschen(int kId, int pId) {
        // DB-Verbindung holen
        Connection con = DBVerbindung.connection();

        try {
            // Leeres SQL-Statement (JDBC) anlegen
            Statement stmt = con.createStatement();

            // Statement ausfüllen und als Query an die DB schicken
            stmt.executeUpdate("DELETE FROM kalender_zugriff_person " +
                    "WHERE kalenderId=" + kId + " AND personId=" + pId);

            System.out.println(KalenderZugriffMapper.class.getName() +
                    " - loeschen ausgeführt.");

        } catch (SQLException ex) {
            Logger.getLogger(KalenderZugriffMapper.class.getName()).
                    log(Level.SEVERE, null, ex);
        }
    }
}
